var search_data = {"index":{"searchIndex":["enumerable","set","&()","+()","-()","<()","<<()","<=()","<=>()","==()","===()",">()",">=()","[]()","^()","add()","add?()","classify()","clear()","collect!()","compare_by_identity()","compare_by_identity?()","delete()","delete?()","delete_if()","difference()","disjoint?()","divide()","each()","empty?()","filter!()","flatten()","flatten!()","include?()","initialize_clone()","initialize_dup()","inspect()","intersect?()","intersection()","join()","keep_if()","length()","map!()","member?()","merge()","new()","proper_subset?()","proper_superset?()","reject!()","replace()","reset()","select!()","size()","subset?()","subtract()","superset?()","to_a()","to_s()","to_set()","to_set()","union()","|()"],"longSearchIndex":["enumerable","set","set#&()","set#+()","set#-()","set#<()","set#<<()","set#<=()","set#<=>()","set#==()","set#===()","set#>()","set#>=()","set::[]()","set#^()","set#add()","set#add?()","set#classify()","set#clear()","set#collect!()","set#compare_by_identity()","set#compare_by_identity?()","set#delete()","set#delete?()","set#delete_if()","set#difference()","set#disjoint?()","set#divide()","set#each()","set#empty?()","set#filter!()","set#flatten()","set#flatten!()","set#include?()","set#initialize_clone()","set#initialize_dup()","set#inspect()","set#intersect?()","set#intersection()","set#join()","set#keep_if()","set#length()","set#map!()","set#member?()","set#merge()","set::new()","set#proper_subset?()","set#proper_superset?()","set#reject!()","set#replace()","set#reset()","set#select!()","set#size()","set#subset?()","set#subtract()","set#superset?()","set#to_a()","set#to_s()","enumerable#to_set()","set#to_set()","set#union()","set#|()"],"info":[["Enumerable","","Enumerable.html","",""],["Set","","Set.html","","<p>This library provides the Set class, which implements a collection\nof unordered values with no duplicates. ...\n"],["&","Set","Set.html#method-i-26","(enum)","<p>Returns a new set containing elements common to the set and the\ngiven enumerable object.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">3</span>, <span class=\"ruby-value\">5</span>] <span class=\"ruby-operator\">...</span>\n</pre>\n"],["+","Set","Set.html#method-i-2B","(enum)",""],["-","Set","Set.html#method-i-2D","(enum)","<p>Returns a new set built by duplicating the set, removing every\nelement that appears in the given enumerable ...\n"],["<","Set","Set.html#method-i-3C","(set)",""],["<<","Set","Set.html#method-i-3C-3C","(o)",""],["<=","Set","Set.html#method-i-3C-3D","(set)",""],["<=>","Set","Set.html#method-i-3C-3D-3E","(set)","<p>Returns 0 if the set are equal,\n-1 / +1 if the set is a proper subset / superset of the given set,\nor ...\n"],["==","Set","Set.html#method-i-3D-3D","(other)","<p>Returns true if two sets are equal. The equality of each couple\nof elements is defined according to  ...\n"],["===","Set","Set.html#method-i-3D-3D-3D","(o)","<p>Returns true if the given object is a member of the set,\nand false otherwise.\n<p>Used in case statements: …\n"],[">","Set","Set.html#method-i-3E","(set)",""],[">=","Set","Set.html#method-i-3E-3D","(set)",""],["[]","Set","Set.html#method-c-5B-5D","(*ary)","<p>Creates a new set containing the given objects.\n\n<pre>Set[1, 2]                   # =&gt; #&lt;Set: {1, 2}&gt;\nSet[1, ...</pre>\n"],["^","Set","Set.html#method-i-5E","(enum)","<p>Returns a new set containing elements exclusive between the set\nand the given enumerable object. <code>(set</code> ...\n"],["add","Set","Set.html#method-i-add","(o)","<p>Adds the given object to the set and returns self. Use <code>merge</code> to\nadd many elements at once.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>].<span class=\"ruby-identifier\">add</span>(<span class=\"ruby-value\">3</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["add?","Set","Set.html#method-i-add-3F","(o)","<p>Adds the given object to the set and returns self. If the\nobject is already in the set, returns nil. ...\n"],["classify","Set","Set.html#method-i-classify","()","<p>Classifies the set by the return value of the given block and\nreturns a hash of {value =&gt; set of elements} ...\n"],["clear","Set","Set.html#method-i-clear","()","<p>Removes all elements and returns self.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">set</span> = <span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-string\">&#39;c&#39;</span>, <span class=\"ruby-value\">:s</span>]             <span class=\"ruby-comment\">#=&gt; #&lt;Set: {1, &quot;c&quot;, :s}&gt;</span>\n<span class=\"ruby-identifier\">set</span>.<span class=\"ruby-identifier\">clear</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["collect!","Set","Set.html#method-i-collect-21","()","<p>Replaces the elements with ones returned by <code>collect()</code>.\nReturns an enumerator if no block is given.\n"],["compare_by_identity","Set","Set.html#method-i-compare_by_identity","()","<p>Makes the set compare its elements by their identity and returns\nself. This method may not be supported ...\n"],["compare_by_identity?","Set","Set.html#method-i-compare_by_identity-3F","()","<p>Returns true if the set will compare its elements by their\nidentity. Also see Set#compare_by_identity ...\n"],["delete","Set","Set.html#method-i-delete","(o)","<p>Deletes the given object from the set and returns self. Use\n<code>subtract</code> to delete many items at once.\n"],["delete?","Set","Set.html#method-i-delete-3F","(o)","<p>Deletes the given object from the set and returns self. If the\nobject is not in the set, returns nil. ...\n"],["delete_if","Set","Set.html#method-i-delete_if","()","<p>Deletes every element of the set for which block evaluates to\ntrue, and returns self. Returns an enumerator ...\n"],["difference","Set","Set.html#method-i-difference","(enum)",""],["disjoint?","Set","Set.html#method-i-disjoint-3F","(set)","<p>Returns true if the set and the given enumerable have\nno element in common. This method is the opposite ...\n"],["divide","Set","Set.html#method-i-divide","(&func)","<p>Divides the set into a set of subsets according to the commonality\ndefined by the given block.\n<p>If the …\n"],["each","Set","Set.html#method-i-each","(&block)","<p>Calls the given block once for each element in the set, passing\nthe element as parameter. Returns an ...\n"],["empty?","Set","Set.html#method-i-empty-3F","()","<p>Returns true if the set contains no elements.\n"],["filter!","Set","Set.html#method-i-filter-21","(&block)","<p>Equivalent to Set#select!\n"],["flatten","Set","Set.html#method-i-flatten","()","<p>Returns a new set that is a copy of the set, flattening each\ncontaining set recursively.\n"],["flatten!","Set","Set.html#method-i-flatten-21","()","<p>Equivalent to Set#flatten, but replaces the receiver with the\nresult in place. Returns nil if no modifications ...\n"],["include?","Set","Set.html#method-i-include-3F","(o)","<p>Returns true if the set contains the given object.\n<p>Note that <code>include?</code> and <code>member?</code> do not test member\nequality ...\n"],["initialize_clone","Set","Set.html#method-i-initialize_clone","(orig, **options)","<p>Clone internal hash.\n"],["initialize_dup","Set","Set.html#method-i-initialize_dup","(orig)","<p>Dup internal hash.\n"],["inspect","Set","Set.html#method-i-inspect","()","<p>Returns a string containing a human-readable representation of the\nset (&quot;#&lt;Set: {element1, element2, ...\n"],["intersect?","Set","Set.html#method-i-intersect-3F","(set)","<p>Returns true if the set and the given enumerable have at least one\nelement in common.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>].<span class=\"ruby-identifier\">intersect?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["intersection","Set","Set.html#method-i-intersection","(enum)",""],["join","Set","Set.html#method-i-join","(separator=nil)","<p>Returns a string created by converting each element of the set to a string\nSee also: Array#join\n"],["keep_if","Set","Set.html#method-i-keep_if","()","<p>Deletes every element of the set for which block evaluates to\nfalse, and returns self. Returns an enumerator ...\n"],["length","Set","Set.html#method-i-length","()",""],["map!","Set","Set.html#method-i-map-21","()",""],["member?","Set","Set.html#method-i-member-3F","(o)",""],["merge","Set","Set.html#method-i-merge","(*enums, **nil)","<p>Merges the elements of the given enumerable objects to the set and\nreturns self.\n"],["new","Set","Set.html#method-c-new","(enum = nil)","<p>Creates a new set containing the elements of the given enumerable\nobject.\n<p>If a block is given, the elements …\n"],["proper_subset?","Set","Set.html#method-i-proper_subset-3F","(set)","<p>Returns true if the set is a proper subset of the given set.\n"],["proper_superset?","Set","Set.html#method-i-proper_superset-3F","(set)","<p>Returns true if the set is a proper superset of the given set.\n"],["reject!","Set","Set.html#method-i-reject-21","(&block)","<p>Equivalent to Set#delete_if, but returns nil if no changes were\nmade. Returns an enumerator if no block ...\n"],["replace","Set","Set.html#method-i-replace","(enum)","<p>Replaces the contents of the set with the contents of the given\nenumerable object and returns self.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">set</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["reset","Set","Set.html#method-i-reset","()","<p>Resets the internal state after modification to existing elements\nand returns self.\n<p>Elements will be reindexed …\n"],["select!","Set","Set.html#method-i-select-21","(&block)","<p>Equivalent to Set#keep_if, but returns nil if no changes were\nmade. Returns an enumerator if no block ...\n"],["size","Set","Set.html#method-i-size","()","<p>Returns the number of elements.\n"],["subset?","Set","Set.html#method-i-subset-3F","(set)","<p>Returns true if the set is a subset of the given set.\n"],["subtract","Set","Set.html#method-i-subtract","(enum)","<p>Deletes every element that appears in the given enumerable object\nand returns self.\n"],["superset?","Set","Set.html#method-i-superset-3F","(set)","<p>Returns true if the set is a superset of the given set.\n"],["to_a","Set","Set.html#method-i-to_a","()","<p>Converts the set to an array. The order of elements is uncertain.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>].<span class=\"ruby-identifier\">to_a</span>                    <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["to_s","Set","Set.html#method-i-to_s","()",""],["to_set","Enumerable","Enumerable.html#method-i-to_set","(klass = Set, *args, &block)","<p>Makes a set from the enumerable object with given arguments.\nNeeds to <code>require &quot;set&quot;</code> to use ...\n"],["to_set","Set","Set.html#method-i-to_set","(klass = Set, *args, &block)","<p>Returns self if no arguments are given. Otherwise, converts the\nset to another with <code>klass.new(self, *args,</code> ...\n"],["union","Set","Set.html#method-i-union","(enum)",""],["|","Set","Set.html#method-i-7C","(enum)","<p>Returns a new set built by merging the set and the elements of the\ngiven enumerable object.\n\n<pre>Set[1, 2, ...</pre>\n"]]}}